Hoe kan ik een specifiek item uit een array verwijderen?

1
2
3
4
De volgende
Zoek de index van het array-element dat u wilt verwijderen met indexOf en verwijder die index vervolgens met splice.
De methode splice () verandert de inhoud van een array door
bestaande elementen en / of het toevoegen van nieuwe elementen.
const array = [2, 5, 9];
console.log (matrix);
const index = array.indexOf (5);
if (index> -1) {
array.splice (index, 1);
}
// array = [2, 9]
console.log (matrix);
De tweede parameter van splitsing is het aantal te verwijderen elementen. Merk op dat splice de array op zijn plaats wijzigt en een nieuwe array retourneert die de elementen bevat die zijn verwijderd.
Voor de volledigheid zijn hier functies. De eerste functie verwijdert slechts één exemplaar (d.w.z. het verwijderen van de eerste overeenkomst van 5 uit [2,5,9,1,5,8,5]), terwijl de tweede functie alle exemplaren verwijdert:
functie removeItemOnce (arr, waarde) {
var index = arr.indexOf (waarde);
if (index> -1) {
arr.splice (index, 1);
}
terugkeer arr;
}
functie removeItemAll (arr, waarde) {
var i = 0;
while (i  = 0; i--) {
if (array [i] === nummer) {
array.splice (i, 1);
}
}
Als je het element op index i gewoon niet meer wilt laten bestaan, maar je wilt niet dat de indexen van de andere elementen veranderen:
verwijder array [i];
|
Bewerkt in oktober 2016
Doe het eenvoudig, intuïtief en expliciet (het scheermes van Occam)
Doe het onveranderlijk (originele array blijft ongewijzigd)
Doe het met standaard JavaScript-functies, als uw browser ze niet ondersteunt - gebruik polyfill
In dit codevoorbeeld gebruik ik de functie "array.filter (...)" om ongewenste items uit een array te verwijderen. Deze functie verandert de oorspronkelijke array niet en maakt een nieuwe aan. Als uw browser deze functie niet ondersteunt (bijvoorbeeld Internet Explorer vóór versie 9 of Firefox vóór versie 1.5), overweeg dan om het filter polyfill van Mozilla te gebruiken.
Item verwijderen (ECMA-262 Edition 5-code ook bekend als oldstyle JavaScript)
var waarde = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (functie (item) {
retour item! == waarde
})
console.log (arr)
// [1, 2, 4, 5]
Item verwijderen (ECMAScript 6-code)
laat waarde = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == waarde)
console.log (arr)
// [1, 2, 4, 5]
BELANGRIJK ECMAScript 6 "() => {}" syntaxis van de pijlfunctie wordt helemaal niet ondersteund in Internet Explorer, Chrome vóór versie 45, Firefox vóór versie 22 en Safari vóór versie 10. Om de ECMAScript 6-syntaxis in oude browsers te gebruiken, kunt u BabelJS gebruiken.
Meerdere items verwijderen (ECMAScript 7-code)
Bijkomend voordeel van deze methode is dat je meerdere items kunt verwijderen
let forDeletion = [2, 3, 5]
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.include (item))
// !!! Lees hieronder over array.inclusief (...) ondersteuning !!!
console.log (arr)
// [1, 4]
BELANGRIJK De functie "array.include (...)" wordt helemaal niet ondersteund in Internet Explorer, Chrome vóór versie 47, Firefox vóór versie 43, Safari vóór versie 9 en Edge vóór versie 14, dus hier is polyfill van Mozilla.
Meerdere items verwijderen (in de toekomst misschien)
Als het voorstel 'This-Binding Syntax' ooit wordt geaccepteerd, kunt u dit doen:
// array-lib.js
exportfunctie verwijderen (... forDeletion) {
retourneer this.filter (item =>! forDeletion.include (item))
}
// main.js
importeer {remove} uit './array-lib.js'
let arr = [1, 2, 3, 4, 5, 3]
// :: Dit bindende syntaxisvoorstel
// gebruik de functie "verwijderen" als "virtuele methode"
// zonder Array.prototype uit te breiden
arr = arr :: remove (2, 3, 5)
console.log (arr)
// [1, 4]
Probeer het zelf in BabelJS :)
Referentie
Array.prototype.inclusief
Functionele samenstelling
|
Het hangt ervan af of u een lege plek wilt behouden of niet.
Als je een leeg slot wilt:
array [index] = niet gedefinieerd;
Als je geen leeg slot wilt:
// Om het origineel te behouden:
// oldArray = [... array];
// Dit wijzigt de array.
array.splice (index, 1);
En als je de waarde van dat item nodig hebt, kun je het geretourneerde array-element gewoon opslaan:
var waarde = array.splice (index, 1) [0];
Als je aan beide uiteinden van de array wilt verwijderen, kun je array.pop () gebruiken voor de laatste of array.shift () voor de eerste (beide retourneren ook de waarde van het item).
Als je de index van het item niet weet, kun je array.indexOf (item) gebruiken om het op te halen (in a if () om één item te krijgen of in een tijdje () om ze allemaal te krijgen). array.indexOf (item) geeft de index of -1 terug als deze niet wordt gevonden.
|
Een vriend had problemen met Internet Explorer 8 en liet me zien wat hij deed. Ik vertelde hem dat het verkeerd was, en hij vertelde me dat hij het antwoord kreeghier. Het huidige beste antwoord zal niet in alle browsers werken (bijvoorbeeld Internet Explorer 8), en het verwijdert alleen de eerste keer dat het item voorkomt.
Verwijder ALLE instanties uit een array
functie array_remove_index_by_value (arr, item)
{
voor (var i = arr.length; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}
}
Het loopt achterwaarts door de array (aangezien indices en lengte veranderen als items worden verwijderd) en verwijdert het item als het wordt gevonden. Het werkt in alle browsers.
|
Er zijn twee belangrijke benaderingen:
splice (): anArray.splice (index, 1);
delete: delete anArray [index];
Wees voorzichtig wanneer u delete voor een array gebruikt. Het is goed voor het verwijderen van attributen van objecten, maar niet zo goed voor arrays. Het is beter om splitsing te gebruiken voor arrays.
Houd er rekening mee dat wanneer u delete voor een array gebruikt, u verkeerde resultaten kunt krijgen voor anArray.length. Met andere woorden, delete zou het element verwijderen, maar de waarde van de eigenschap length zou niet worden bijgewerkt.
U kunt ook verwachten dat er gaten in indexnummers ontstaan ​​na het gebruik van verwijderen, bijv. je zou kunnen eindigen met indexen 1, 3, 4, 8, 9 en 11 en de lengte zoals het was voordat je delete gebruikte. In dat geval zouden alle geïndexeerde lussen crashen, aangezien indexen niet langer sequentieel zijn.
Als je om de een of andere reden gedwongen wordt delete te gebruiken, dan zou je voor elke loops moeten gebruiken als je door arrays moet lussen. Vermijd trouwens altijd het gebruik van geïndexeerde for-lussen, indien mogelijk. Op die manier zou de code robuuster zijn en minder vatbaar voor problemen met indexen.
|
Array.prototype.remove_by_value = functie (val) {
voor (var i = 0; i  row.id === 5);
var verwijderd = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Definitie
var helper = {
// Verwijder en retourneer het eerste exemplaar
removeOne: function (array, predikaat) {
voor (var i = 0; i  [2, 3, 4]
|
U kunt ES6 gebruiken. Om in dit geval bijvoorbeeld de waarde '3' te verwijderen:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((waarde) => waarde! = '3');
console.log (newArray);
Uitgang:
["1", "2", "4", "5", "6"]
|
Als u een nieuwe array wilt waarvan de verwijderde posities zijn verwijderd, kunt u altijd het specifieke element verwijderen en de array eruit filteren. Het kan een uitbreiding van het array-object nodig hebben voor browsers die de filtermethode niet implementeren, maar op de lange termijn is het gemakkelijker omdat je alleen dit hoeft te doen:
var my_array = [1, 2, 3, 4, 5, 6];
verwijder my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
Het zou [1, 2, 3, 4, 6] moeten weergeven.
|
Hier zijn een paar manieren om een ​​item uit een array te verwijderen met JavaScript.
Alle beschreven methoden muteren de oorspronkelijke array niet, maar maken in plaats daarvan een nieuwe.
Als je de index van een item kent
Stel dat u een array heeft en u wilt een item op positie i verwijderen.
Een methode is om slice () te gebruiken:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const ik = 3
const filterItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (gefilterdeItems)
slice () maakt een nieuwe array aan met de indexen die het ontvangt. We maken gewoon een nieuwe array, van het begin tot de index die we willen verwijderen, en voegen een andere array samen vanaf de eerste positie, volgend op degene die we hebben verwijderd, tot het einde van de array.
Als je de waarde kent
In dit geval is een goede optie om filter () te gebruiken, dat een meer declaratieve benadering biedt:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filterItems = items.filter (item => item! == valueToRemove)
console.log (gefilterdeItems)
Dit maakt gebruik van de ES6-pijlfuncties. U kunt de traditionele functies gebruiken om oudere browsers te ondersteunen:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filterItems = items.filter (functie (item) {
item retourneren! == valueToRemove
})
console.log (gefilterdeItems)
of je kunt Babel gebruiken en de ES6-code terugzetten naar ES5 om het beter verteerbaar te maken voor oude browsers, maar toch modern JavaScript in je code schrijven.
Meerdere items verwijderen
Wat als u in plaats van één item veel items wilt verwijderen?
Laten we de eenvoudigste oplossing vinden.
Door index
U kunt gewoon een functie maken en items in serie verwijderen:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (items, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
laat filterItems = removeItem (items, 3)
filterItems = removeItem (filterItems, 5)
// ["a", "b", "c", "d"]
console.log (gefilterdeItems)
Op waarde
U kunt zoeken naar opname in de callback-functie:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valuesToRemove = ['c', 'd']
const filterItems = items.filter (item =>! valuesToRemove.include (item))
// ["a", "b", "e", "f"]
console.log (gefilterdeItems)
Vermijd het muteren van de originele array
splice () (niet te verwarren met slice ()) muteert de oorspronkelijke array en moet worden vermeden.
(oorspronkelijk gepost op mijn site https://flaviocopes.com/how-to-remove-item-from-array/)
|
Bekijk deze code. Het werkt in elke grote browser.
remove_item = functie (arr, waarde) {
var b = '';
voor (b in arr) {
if (arr [b] === waarde) {
arr.splice (b, 1);
breken;
}
}
terugkeer arr;
};
Roep deze functie aan
remove_item (array, waarde);
|
ES6 & zonder mutatie: (oktober 2016)
const removeByIndex = (lijst, index) =>
[
... list.slice (0, index),
... list.slice (index + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (uitvoer)
|
U kunt lodash _.pull (matrix muteren), _.pullAt (matrix muteren) of _.without (matrix niet muteren) gebruiken,
var array1 = ['a', 'b', 'c', 'd']
_.pull (array1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (array2; 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Het verwijderen van een bepaald element / string uit een array kan gedaan worden in een oneliner:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
waar:
theArray: de array waaruit u iets specifieks wilt verwijderen
stringToRemoveFromArray: de string die u wilt verwijderen en 1 is het aantal elementen dat u wilt verwijderen.
NOTITIE: Als "stringToRemoveFromArray" niet in uw array staat, zal dit het laatste element van de array verwijderen.
Het is altijd een goede gewoonte om eerst te controleren of het element in uw array bestaat, voordat u het verwijdert.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Als u toegang heeft tot nieuwere Ecmascript-versies op de computers van uw cliënt (WAARSCHUWING, werkt mogelijk niet op oudere stations):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((waarde) => waarde! = '3');
Waar '3' de waarde is die u uit de array wilt verwijderen.
De array wordt dan: ['1', '2', '4', '5', '6']
|
OK, je hebt bijvoorbeeld de onderstaande array:
var num = [1, 2, 3, 4, 5];
En we willen nummer 4 verwijderen. U kunt eenvoudig de onderstaande code gebruiken:
num.splice (num.indexOf (4), 1); // num zal [1, 2, 3, 5] zijn;
Als u deze functie hergebruikt, schrijft u een herbruikbare functie die zoals hieronder aan de native array-functie wordt gekoppeld:
Array.prototype.remove = Array.prototype.remove || functie (x) {
const i = this.indexOf (x);
if (i === - 1)
terugkeren;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Maar hoe zit het als je de onderstaande array in plaats daarvan hebt met een paar [5] s in de array?
var num = [5, 6, 5, 4, 5, 1, 5];
We hebben een lus nodig om ze allemaal te controleren, maar een eenvoudigere en efficiëntere manier is het gebruik van ingebouwde JavaScript-functies, dus we schrijven een functie die een filter zoals hieronder gebruikt:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Er zijn ook bibliotheken van derden die u hierbij helpen, zoals Lodash of Underscore. Voor meer informatie, kijk op lodash _.pull, _.pullAt of _.without.
|
Prestatie
Vandaag (09-12-2019) voer ik prestatietests uit op macOS v10.13.6 (High Sierra) voor gekozen oplossingen. Ik laat delete (A) zien, maar ik gebruik het niet in vergelijking met andere methoden, omdat het lege ruimte in de array heeft achtergelaten.
De conclusies
de snelste oplossing is array.splice (C) (behalve Safari voor kleine arrays waar het de tweede keer is)
voor grote arrays is array.slice + splice (H) de snelste onveranderlijke oplossing voor Firefox en Safari; Array.from (B) is de snelste in Chrome
veranderlijke oplossingen zijn meestal 1,5x-6x sneller dan onveranderlijk
voor kleine tabellen op Safari is verrassend genoeg de veranderlijke oplossing (C) langzamer dan de onveranderlijke oplossing (G)
Details
Bij tests verwijder ik het middelste element op verschillende manieren uit de array. De A, C-oplossingen zijn aanwezig. De B, D, E, F, G, H-oplossingen zijn onveranderlijk.
Resultaten voor array met 10 elementen
In Chrome is de array.splice (C) de snelste in-place-oplossing. De array.filter (D) is de snelste onveranderlijke oplossing. De langzaamste is array.slice (F). U kunt de test hier op uw machine uitvoeren.
Resultaten voor array met 1.000.000 elementen
In Chrome is de array.splice (C) de snelste in-place-oplossing (de delete (C) is vergelijkbaar snel - maar er is een leeg slot in de array achtergelaten (dus het voert geen 'volledige verwijdering' uit)). De array.slice-splice (H) is de snelste onveranderlijke oplossing. De langzaamste is array.filter (D en E). U kunt de test hier op uw machine uitvoeren.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
functie A (array) {
var index = array.indexOf (5);
verwijder array [index];
log ('A', matrix);
}
functie B (matrix) {
var index = array.indexOf (5);
var arr = Array.from (array);
arr.splice (index, 1)
log ('B', arr);
}
functie C (matrix) {
var index = array.indexOf (5);
array.splice (index, 1);
log ('C', matrix);
}
functie D (array) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
functie E (array) {
var index = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
log ('E', arr);
}
functie F (array) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
log ('F', arr);
}
functie G (array) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
log ('G', arr);
}
functie H (matrix) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (index, 1);
log ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
Fa]);
G ([... a]);
H ([... a]);
Dit fragment presenteert alleen code die wordt gebruikt in prestatietests - het voert zelf geen tests uit.
Vergelijking voor browsers: Chrome v78.0.0, Safari v13.0.4 en Firefox v71.0.0
|
Ik ben vrij nieuw in JavaScript en had deze functionaliteit nodig. Ik schreef alleen dit:
functie removeFromArray (array, item, index) {
while ((index = array.indexOf (item))> -1) {
array.splice (index, 1);
}
}
Als ik het dan wil gebruiken:
// Stel enkele dummy-gegevens in
var dummyObj = {naam: "meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Verwijder de dummy-gegevens
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Uitvoer - zoals verwacht.
["item1", "item1"]
Mogelijk heeft u andere wensen dan ik, dus u kunt deze eenvoudig aanpassenom bij hen te passen. Ik hoop dat dit iemand helpt.
|
Als u complexe objecten in de array heeft, kunt u filters gebruiken?
In situaties waarin $ .inArray of array.splice niet zo gemakkelijk te gebruiken is. Vooral als de objecten misschien ondiep zijn in de array.
Bijv. als je een object met een Id-veld hebt en je wilt dat het object uit een array wordt verwijderd:
this.array = this.array.filter (functie (element, i) {
return element.id! == idToRemove;
});
|
Ik wil antwoorden op basis van ECMAScript 6. Stel dat je een array hebt zoals hieronder:
let arr = [1,2,3,4];
Als u wilt verwijderen met een speciale index zoals 2, schrijft u de onderstaande code:
arr.splice (2, 1); // => arr werd [1,2,4]
Maar als u een speciaal item zoals 3 wilt verwijderen en u de index niet kent, doet u het volgende:
arr = arr.filter (e => e! == 3); // => arr werd [1,2,4]
Hint: gebruik a.u.b. een pijlfunctie voor filter callback, tenzij je een lege array krijgt.
|
Update: deze methode wordt alleen aanbevolen als u ECMAScript 2015 (voorheen bekend als ES6) niet kunt gebruiken. Als je het kunt gebruiken, bieden andere antwoorden hier veel nettere implementaties.
Deze kern lost uw probleem op, en verwijdert ook alle exemplaren van het argument in plaats van slechts 1 (of een opgegeven waarde).
Array.prototype.destroy = functie (obj) {
// Retourneer null als er geen objecten zijn gevonden en verwijderd
var vernietigd = null;
voor (var i = 0; i  3
x.destroy (false); // => false
X; // => [1, 2, waar, niet gedefinieerd]
x.destroy (true); // => waar
x.destroy (niet gedefinieerd); // => niet gedefinieerd
X; // => [1, 2]
x. vernietigen (3); // => null
X; // => [1, 2]
|
ES10-update
Dit bericht geeft een overzicht van veelgebruikte benaderingen voor het verwijderen van elementen uit de array vanaf ECMAScript 2019 (ES10).
1. Algemene gevallen
1.1. Array-element op waarde verwijderen met .splice ()
| Ter plaatse: Ja |
| Verwijdert duplicaten: Ja (lus), Nee (indexOf) |
| Op waarde / index: op index |
Als u de waarde weet die u uit een array wilt verwijderen, kunt u de splice-methode gebruiken. Eerst moet u de index van het doelitem identificeren. U gebruikt dan de index als startelement en verwijdert slechts één element.
// Met een 'for'-lus
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (let i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Met de .indexOf () methode
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Array-element verwijderen met behulp van de .filter () - methode
| Ter plaatse: Nee |
| Verwijdert duplicaten: Ja |
| Op waarde / index: op waarde |
Een specifiek element kan uit de array worden gefilterd door een filterfunctie te bieden. Een dergelijke functie wordt dan aangeroepen voor elk element in de array.
const waarde = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == waarde)
console.log (arr)
// [1, 2, 4, 5]
1.3. Array-element verwijderen door Array.prototype uit te breiden
| Ter plaatse: ja / nee (afhankelijk van implementatie) |
| Verwijdert duplicaten: Ja / Nee (afhankelijk van implementatie) |
| Op waarde / index: op index / op waarde (afhankelijk van implementatie) |
Prototype van Array kan worden uitgebreid met aanvullende methoden. Dergelijke methoden zijn dan beschikbaar voor gebruik op gemaakte arrays.
Opmerking: het uitbreiden van prototypen van objecten uit de standaardbibliotheek van JavaScript (zoals Array) wordt door sommigen als een antipatroon beschouwd.
// Ter plaatse, verwijdert alles, door waarde-implementatie
Array.prototype.remove = functie (item) {
for (let i = 0; i  = ES10)
| Ter plaatse: Nee |
| Verwijdert duplicaten: Ja |
| Op waarde / index: op waarde |
ES10 introduceerde Object.fromEntries, wat kan zijnwordt gebruikt om de gewenste array te maken van elk array-achtig object en tijdens het proces ongewenste elementen te filteren.
const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (object)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Bijzondere gevallen
2.1 Element verwijderen als het zich aan het einde van de array bevindt
2.1.1. De lengte van de array wijzigen
| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde / index: N / A |
JavaScript-array-elementen kunnen aan het einde van een array worden verwijderd door de eigenschap length in te stellen op een waarde die kleiner is dan de huidige waarde. Elk element waarvan de index groter is dan of gelijk is aan de nieuwe lengte, wordt verwijderd.
const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Stel de lengte in om het element te verwijderen
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Gebruik de .pop () methode
| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde / index: N / A |
De pop-methode verwijdert het laatste element van de array, retourneert dat element en werkt de eigenschap length bij. De pop-methode wijzigt de array waarop het wordt aangeroepen. Dit betekent dat, in tegenstelling tot het gebruik van delete, het laatste element volledig wordt verwijderd en de array-lengte wordt verkleind.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // retourneert 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Element verwijderen als het aan het begin van de array staat
| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde / index: N / A |
De .shift () -methode werkt ongeveer zoals de pop-methode, behalve dat het eerste element van een JavaScript-array wordt verwijderd in plaats van het laatste. Wanneer het element wordt verwijderd, worden de resterende elementen naar beneden geschoven.
const arr = [1, 2, 3, 4];
arr.shift (); // retourneert 1
console.log (arr); // [2, 3, 4]
2.3. Element verwijderen als dit het enige element in de array is
| Ter plaatse: Ja |
| Verwijdert duplicaten: nvt |
| Op waarde / index: N / A |
De snelste techniek is om een ​​arrayvariabele in te stellen op een lege array.
let arr = [1];
arr = []; // lege array
Als alternatief kan de techniek uit 2.1.1 worden gebruikt door de lengte in te stellen op 0.
|
U mag uw array nooit muteren. Omdat dit in strijd is met het functionele programmeerpatroon. U kunt een nieuwe array maken zonder te verwijzen naar de array waarvan u de gegevens wilt wijzigen, met behulp van het ECMAScript 6-methodefilter;
var myArray = [1, 2, 3, 4, 5, 6];
Stel dat u 5 uit de array wilt verwijderen, dan kunt u dit eenvoudig als volgt doen:
myArray = myArray.filter (waarde => waarde! == 5);
Dit geeft je een nieuwe array zonder de waarde die je wilde verwijderen. Het resultaat zal dus zijn:
[1, 2, 3, 4, 6]; // 5 is verwijderd uit deze array
Voor meer informatie kunt u de MDN-documentatie op Array.filter lezen.
|
Een modernere ECMAScript 2015-benadering (voorheen bekend als Harmony of ES 6). Gegeven:
const items = [1, 2, 3, 4];
const index = 2;
Dan:
items.filter ((x, i) => i! == index);
Opbrengst:
[1, 2, 4]
U kunt Babel en een polyfill-service gebruiken om ervoor te zorgen dat dit goed wordt ondersteund in alle browsers.
|
U kunt een achterwaartse lus maken om ervoor te zorgen dat u de indexen niet verknoeit, als er meerdere instanties van het element zijn.
var myElement = "chocolate";
var myArray = ['chocolade', 'poptart', 'poptart', 'poptart', 'chocolade', 'poptart', 'poptart', 'chocolade'];
/ * Belangrijke code * /
voor (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Live demonstratie
|
Je hebt 1 tot 9 in de array en je wilt 5 verwijderen. Gebruik de onderstaande code:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
retourneer m! == 5;
});
console.log ("nieuwe array, 5 verwijderd", newNumberArray);
Als u meerdere waarden wilt. Voorbeeld: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("nieuwe Array, 1,7 en 8 verwijderd", newNumberArray);
Als u een arraywaarde in een array wilt verwijderen. Voorbeeld: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removeebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removeebleArray.include (m);
});
console.log ("nieuwe Array, [3,4,5] verwijderd", newNumberArray);
Inclusief ondersteunde browser is link.
|
1
2
3
4
De volgende
Zeer actieve vraag. Verdien 10 reputatie om deze vraag te beantwoorden. De reputatievereiste helpt deze vraag te beschermen tegen spam en niet-beantwoording.
Niet het antwoord waar je naar zoekt? Blader door andere vragen met de tag javascript-arrays of stel uw eigen vraag.